home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2001 / MacHack 2001.toast / pc / The Hacks / HFS- / SerialFSServ / SerialServ.c < prev   
Encoding:
Text File  |  2001-06-23  |  5.5 KB  |  274 lines
  1. // GenericSerial.c
  2. // Used on Mac & Palm platforms, for both the server/client apps
  3.  
  4. #include    <Types.h>
  5.  
  6.  
  7. #include "GenericSerial.h"
  8.  
  9. #ifndef NULL
  10.     #define NULL (0L)
  11. #endif
  12.  
  13. static MyPacket    gInPacket;
  14.  
  15. static char        gInBuf[kMaxExtraDataSize];
  16. static char        gOutBuf[sizeof(MyPacket) + kMaxExtraDataSize];
  17.  
  18.  
  19. static void Reply(long p1, long p2, long p3, long p4, short dataSize, short result);
  20.  
  21. static void Send(short op, long p1, long p2, long p3, long p4, short dataSize, char* bufP);
  22. static void Receive(long *p1, long *p2, long *p3, long *p4, short *resultP, char *bufP);
  23.  
  24.  
  25. // called repeatedly by main event loop of server application
  26. void ServeSomething(void)
  27. {
  28.     short err;
  29.     long filep = 0;
  30.     long numBytes, size, iterator, attr;
  31.     // request a message:
  32.     err = SerialRead(sizeof(MyPacket), (char*)&gInPacket);
  33.     
  34.     if(err != 0) return; // (0 = noErr = errNone :-)
  35.     
  36.     // check the cookie so we know we're interpreting the data correctly
  37.     if(gInPacket.cookie != kCookieValue) return;
  38.     if(gInPacket.dataSize > kMaxExtraDataSize) return;
  39.     
  40.     if(gInPacket.dataSize > 0)
  41.     {
  42.         if(gInPacket.dataSize > kMaxExtraDataSize) return;
  43.         
  44.         err = SerialRead(gInPacket.dataSize, gInBuf);
  45.         if(err != 0) return; // (0 = noErr = errNone :-)
  46.     }
  47.     
  48.     
  49.     switch(gInPacket.op)
  50.     {
  51.         case kDirEnumerate:
  52.             // param1 - dirp
  53.             // param2 - iterator
  54.             
  55.             //Debugger();
  56.             iterator = gInPacket.param2;
  57.             err = LocalDirIterate(gInPacket.param1, (unsigned long*)&iterator, gOutBuf, &size, &attr);
  58.             
  59.             // reply:
  60.             // param1 - new iterator
  61.             // param2 - attributes
  62.             // result - result code
  63.             // extra data - file name, etc...
  64.             if(err) 
  65.             {
  66.                 Reply(iterator, 0, 0, 0, 0, err);
  67.             }
  68.             else
  69.             {
  70.                 Reply(iterator, attr, 0, 0, size+1, err);
  71.             }
  72.             
  73.             break;
  74.         
  75.         case kFileCreate:
  76.             // extra data - pathname
  77.             
  78.             //Debugger();
  79.             
  80.             // make sure we have a path:
  81.             if(gInPacket.dataSize == 0) Reply(0,0,0,0,0,-1);
  82.             err = LocalFileCreate(gInBuf);
  83.             
  84.             // reply:
  85.             // result - result code
  86.             Reply(0, 0, 0, 0, 0, err);
  87.             
  88.             
  89.             break;
  90.         
  91.         case kDirCreate:
  92.             // extra data - pathname
  93.             
  94.             //Debugger();
  95.             
  96.             // make sure we have a path:
  97.             if(gInPacket.dataSize == 0) Reply(0,0,0,0,0,-1);
  98.             err = LocalDirCreate(gInBuf);
  99.             
  100.             // reply:
  101.             // result - result code
  102.             Reply(0, 0, 0, 0, 0, err);
  103.             
  104.             
  105.             break;
  106.         
  107.         
  108.         case kFileOpen:
  109.             // param1 - permissions
  110.             // extra data - pathname
  111.             
  112.             //Debugger();
  113.             
  114.             // make sure we have a path:
  115.             filep = 0;
  116.             if(gInPacket.dataSize == 0) Reply(0,0,0,0,0,-1);
  117.             err = LocalFileOpen(gInBuf, gInPacket.param1, &filep);
  118.             
  119.             // reply:
  120.             // param1 - file ptr
  121.             // result - result code
  122.             Reply(filep, 0, 0, 0, 0, err);
  123.             
  124.             //Debugger();
  125.             
  126.             break;
  127.         
  128.         case kFileClose:
  129.             // param1 - filep
  130.             
  131.             //Debugger();
  132.             err = LocalFileClose(gInPacket.param1);
  133.             
  134.             // reply:
  135.             // result - result code
  136.             Reply(0, 0, 0, 0, 0, err);
  137.             
  138.             break;
  139.         
  140.         case kFileRead:
  141.             // param1 - filep
  142.             // param2 - numBytes
  143.             
  144.             numBytes = gInPacket.param2;
  145.             //Debugger();
  146.  
  147.             if(numBytes > kMaxExtraDataSize) Reply(0,0,0,0,0,-1);
  148.             
  149.             // read the data...
  150.             err = LocalFileRead(gInPacket.param1, numBytes, &numBytes, gOutBuf);
  151.             
  152.             // send the data back...
  153.             // reply:
  154.             // param1 - number of bytes read (in this message)
  155.             // result - possibly error code
  156.             Reply(numBytes, 0, 0, 0, numBytes, err);
  157.                         
  158.             break;
  159.         
  160.         case kFileWrite:
  161.             // param1 - filep
  162.             // param2 - numBytes
  163.             // extra data - data to write
  164.             
  165.             numBytes = gInPacket.param2;
  166.             
  167.             //Debugger();
  168.             
  169.             // sanity check:
  170.             if(numBytes != gInPacket.dataSize) Reply(0,0,0,0,0,-1);
  171.             
  172.             // write the data...
  173.             err = LocalFileWrite(gInPacket.param1, numBytes, &numBytes, gInBuf);
  174.             
  175.             // send the reply back...
  176.             // reply:
  177.             // param1 - number of bytes read (in this message)
  178.             // result - possibly error code
  179.             Reply(numBytes, 0, 0, 0, 0, err);
  180.                         
  181.             break;
  182.         
  183.         case kFileSeek:
  184.             // param1 - filep
  185.             // param2 - origin
  186.             // param3 - offset
  187.             
  188.             //Debugger();
  189.             err = LocalFileSeek(gInPacket.param1, gInPacket.param2, gInPacket.param3);
  190.             
  191.             // reply:
  192.             // result - result code
  193.             Reply(0, 0, 0, 0, 0, err);
  194.             
  195.             break;
  196.         
  197.         case kFileSize:
  198.             // param1 - filep
  199.             
  200.             //Debugger();
  201.             err = LocalFileSize(gInPacket.param1, &size);
  202.             
  203.             // reply:
  204.             // p1 - size of file
  205.             // result - result code
  206.             Reply(size, 0, 0, 0, 0, err);
  207.             
  208.             break;
  209.         
  210.         case kFileResize:
  211.             // param1 - filep
  212.             // param2 - new size
  213.             
  214.             //Debugger();
  215.             err = LocalFileResize(gInPacket.param1, gInPacket.param2);
  216.             
  217.             // reply:
  218.             // p1 - size of file
  219.             // result - result code
  220.             Reply(0, 0, 0, 0, 0, err);
  221.             
  222.             break;
  223.         
  224.         case kFileRename:
  225.             // unimplemented
  226.             DebugStr("\prename unimplemented");
  227.             break;
  228.         
  229.         case kFileDelete:
  230.             // extra data - path
  231.             err = LocalFileDelete(gInBuf);
  232.             
  233.             // Reply:
  234.             // result - result code
  235.             Reply(0, 0, 0, 0, 0, err);
  236.             
  237.             break;
  238.         
  239.         default:
  240.             DebugStr("\pUnrecognized command");
  241.     }
  242.     
  243.     
  244.     return;
  245. }
  246.  
  247. // send a reply to client:
  248. void Reply(long p1, long p2, long p3, long p4, short dataSize, short result) 
  249. {
  250.     MyPacket    outPacket;
  251.     short        err;
  252.     
  253.     // initialize outPacket:
  254.     outPacket.cookie = kCookieValue;
  255.     outPacket.op = gInPacket.op;//kFileOpResult;
  256.     outPacket.dataSize = dataSize;
  257.     outPacket.result = result;
  258.     outPacket.reserved = 0;
  259.     outPacket.param1 = p1;
  260.     outPacket.param2 = p2;
  261.     outPacket.param3 = p3;
  262.     outPacket.param4 = p4;
  263.     
  264.     err = SerialWrite(sizeof(MyPacket), (char*)&outPacket);
  265.     
  266.     if(err == 0 && dataSize > 0)
  267.     {
  268.         // send extra data, if any:
  269.         err = SerialWrite(dataSize, gOutBuf);
  270.     }
  271.     
  272.     return;
  273. }
  274.